package com.eastjet.equipment.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.eastjet.equipment.mapper.DeviceEfdMapper;
import com.eastjet.equipment.service.DeviceEfdService;
import com.eastjet.equipment.service.DeviceRulesService;
import com.eastjet.equipment.util.CodeRules;
import com.eastjet.equipment.util.PageUtil;
import com.eastjet.equipment.util.RedisUtil;
import com.eastjet.maintenance.domain.*;

import com.ruoyi.common.core.domain.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author 杨博文
 * @description 针对表【device_efd(设备故障库表)】的数据库操作Service实现
 * @createDate 2024-11-25 09:23:37
 */
@Service
public class DeviceEfdServiceImpl extends ServiceImpl<DeviceEfdMapper, DeviceEfd> implements DeviceEfdService {

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private DeviceEfdMapper deviceEfdMapper;

    @Autowired
    private DeviceRulesService deviceRulesService;

    @Autowired
    private CodeRules codeRules;

    @Override
    public Page<DeviceEfd> getEfdList(int page, int size, String condition) {
        // 定义Redis中的键
        String redisKey = "DeviceEfdList:";
        System.out.println("DeviceEfdList-condition:" + condition);
        // 先查缓存Redis
        if (redisUtil.hasKey(redisKey)) {
            System.out.println(1);
            System.out.println("DeviceEfdList-从Redis中获取数据");
            List<DeviceEfd> DeviceEfdList;
            if (condition != null && !condition.isEmpty() && condition != "") {
                System.out.println(2);
                DeviceEfdList = deviceEfdMapper.selectByCondition(condition); // 获取所有数据
            } else {
                System.out.println(3);
                DeviceEfdList = (List<DeviceEfd>) redisUtil.get(redisKey);
            }
            // 使用PageUtil进行分页
            return PageUtil.paginate(DeviceEfdList, page, size);
        } else {
            System.out.println(4);
            System.out.println("在数据库中查询DeviceEfdList");
            List<DeviceEfd> DeviceEfdList;
            // 根据condition条件查询
            if (condition != null && !condition.isEmpty() && condition != "") {
                System.out.println(5);
                DeviceEfdList = deviceEfdMapper.selectByCondition(condition);
            } else {
                System.out.println(6);
                condition = "";
                DeviceEfdList = deviceEfdMapper.selectByCondition(condition); // 获取所有数据
                // 将数据存入Redis
                redisUtil.set(redisKey, DeviceEfdList);
            }
            // 使用PageUtil进行分页
            return PageUtil.paginate(DeviceEfdList, page, size);
        }
    }

    @Override
    public String addDeviceEfd(DeviceEfd deviceEfd) {
        System.out.println("deviceEfdList:" + deviceEfd.toString());
        try {
            // 尝试将数据插入数据库
            if (deviceEfdMapper.insertDeviceEfd(deviceEfd) > 0) {
                // 定义Redis的键
                String redisKey = "DeviceEfdList:";
                try {
                    // 从数据库获取当前所有数据
                    List<DeviceEfd> deviceEfdList = deviceEfdMapper.selectByCondition(null); // 可以根据需要替换为实际查询条件
                    // 将更新后的数据写入Redis
                    redisUtil.set(redisKey, deviceEfdList);
                } catch (Exception e) {
                    // 处理Redis操作异常
                    System.err.println("Redis更新失败: " + e.getMessage());
                    // 这里可以根据实际情况决定是否要抛出异常或者进行其他处理
                }
                return "新增成功";
            } else {
                return "新增失败";
            }
        } catch (Exception e) {
            // 处理数据库操作异常
            System.err.println("数据库操作失败: " + e.getMessage());
            return "修改失败";
        }
    }

    @Override
    public String updateDeviceEfd(DeviceEfd deviceEfd) {
        System.out.println("deviceEfdList:" + deviceEfd.toString());
        try {
            // 尝试将数据插入数据库
            if (deviceEfdMapper.updateDeviceEfd(deviceEfd) > 0) {
                // 定义Redis的键
                String redisKey = "DeviceEfdList:";
                try {
                    // 从数据库获取当前所有数据
                    List<DeviceEfd> deviceEfdList = deviceEfdMapper.selectByCondition(null); // 可以根据需要替换为实际查询条件
                    // 将更新后的数据写入Redis
                    redisUtil.set(redisKey, deviceEfdList);
                } catch (Exception e) {
                    // 处理Redis操作异常
                    System.err.println("Redis更新失败: " + e.getMessage());
                    // 这里可以根据实际情况决定是否要抛出异常或者进行其他处理
                }
                return "修改成功";
            } else {
                return "修改失败";
            }
        } catch (Exception e) {
            // 处理数据库操作异常
            System.err.println("数据库操作失败: " + e.getMessage());
            return "修改失败";
        }
    }

    @Override
    public String deleteDeviceEfd(DeviceEfd deviceEfd) {
        System.out.println("deviceEfdList:" + deviceEfd.toString());
        try {
            // 尝试将数据插入数据库
            if (deviceEfdMapper.deleteDeviceEfd(deviceEfd) > 0) {
                // 定义Redis的键
                String redisKey = "DeviceEfdList:";
                try {
                    // 从数据库获取当前所有数据
                    List<DeviceEfd> deviceRkbList = deviceEfdMapper.selectByCondition(null); // 可以根据需要替换为实际查询条件
                    // 将更新后的数据写入Redis
                    redisUtil.set(redisKey, deviceRkbList);
                } catch (Exception e) {
                    // 处理Redis操作异常
                    System.err.println("Redis更新失败: " + e.getMessage());
                    // 这里可以根据实际情况决定是否要抛出异常或者进行其他处理
                }
                return "删除成功";
            } else {
                return "删除失败";
            }
        } catch (Exception e) {
            // 处理数据库操作异常
            System.err.println("数据库操作失败: " + e.getMessage());
            return "删除失败";
        }
    }

    @Override
    public String updateDeviceEfdState(DeviceEfd deviceEfd) {
        System.out.println("deviceEfdList:" + deviceEfd.toString());
        try {
            // 尝试将数据插入数据库
            if (deviceEfdMapper.updateStateDeviceEfd(deviceEfd) > 0) {
                // 定义Redis的键
                String redisKey = "DeviceEfdList:";
                try {
                    // 从数据库获取当前所有数据
                    List<DeviceEfd> deviceRkbList = deviceEfdMapper.selectByCondition(null); // 可以根据需要替换为实际查询条件
                    // 将更新后的数据写入Redis
                    redisUtil.set(redisKey, deviceRkbList);
                } catch (Exception e) {
                    // 处理Redis操作异常
                    System.err.println("Redis更新失败: " + e.getMessage());
                    // 这里可以根据实际情况决定是否要抛出异常或者进行其他处理
                }
                return "修改成功";
            } else {
                return "修改失败";
            }
        } catch (Exception e) {
            // 处理数据库操作异常
            System.err.println("数据库操作失败: " + e.getMessage());
            return "修改失败";
        }
    }

    @Override
    public List<DeviceType> getDeviceType() {
        // 定义Redis中的键
        String redisKey = "DeviceTypeList:";
        System.out.println("DeviceTypeList");


        // 先查缓存Redis
        if (redisUtil.hasKey(redisKey)) {
            System.out.println(1);
            System.out.println("DeviceEfdList-从Redis中获取数据");
            List<DeviceType> DeviceTypeList;
            System.out.println(3);
            DeviceTypeList = (List<DeviceType>) redisUtil.get(redisKey);
            return DeviceTypeList;
        } else {
            System.out.println(4);
            System.out.println("在数据库中查询DeviceEfdList");
            List<DeviceType> DeviceTypeList;
            // 根据condition条件查询

            System.out.println(6);
            DeviceTypeList = deviceEfdMapper.getType(); // 获取所有数据
            // 将数据存入Redis
            redisUtil.set(redisKey, DeviceTypeList);
            return DeviceTypeList;
        }
    }


}




